Hi Andreas, hope you're doing well!
I came up with this solution, which is more similar to Arjan's v1 version.

************ Start code**************
from dataclasses import dataclass
from typing import Any
from time import perf_counter

import requests
import asyncio

API_KEY = "123456"

@dataclass
class UrlTemplateClient:
template: str

def get(self, data: dict[str, Any]) -> Any:
url = self.template.format(**data)
response = requests.get(url, timeout=5)
response.raise_for_status() # Raise an exception if the request failed
return response.json()

async def a_get(self, data: dict[str, Any]) -> Any:
return await asyncio.to_thread(self.get, data)

class CityNotFoundError(Exception):
pass

async def get_capital(country: str) -> str:
client = UrlTemplateClient(template="https://restcountries.com/v3/name/{country}")
response = await client.a_get({"country": country})

# The API can return multiple matches, so we just return the capital of the first match
return response[0]["capital"][0]

async def get_forecast(city: str) -> dict[str, Any]:
client = UrlTemplateClient(
template=f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}"
)
response = await client.a_get({"city": city})
if "main" not in response:
raise CityNotFoundError(
f"Couldn't find weather data. Check '{city}' if it exists and is correctly spelled.\n"
)
return response

def get_temperature(full_weather_forecast: dict[str, Any]) -> float:
temperature = full_weather_forecast["main"]["temp"]
return temperature - 273.15 # convert from Kelvin to Celsius

async def async_main() -> None:
countries = ["United States of America", "Australia", "Japan", "France", "Brazil","Argentina"]
start = perf_counter()
country_capitals = await asyncio.gather(*[get_capital(country) for country in countries])

capital_wheater_forecasts = await asyncio.gather(*[get_forecast(city) for city in country_capitals])

for index, country in enumerate(countries):
print(f"The capital of {country} is {country_capitals[index]}")
print(
f"The current temperature in {country_capitals[index]} is {get_temperature(capital_wheater_forecasts[index]):.1f} °C."
)

print(f'Total elapsed time: {perf_counter() - start}')

if __name__ == "__main__":
asyncio.run(async_main())

************ End code**************
I've really enjoyed this challenge.
I still have to get used to using zip.

Have a nice week end!

Hi, I just want to say that when usage of concurrency is limited and simple, a nice solution is to use the ThreadPoolExecuter or ProcessPoolExecutor objects for the concurrent.futures module (standard library). The API is very nice and it can be used as a contect manager.

I think that if you need to do the same operation in parallel (do some image processing on a collection of images, do many API calls in parallel etc...), than this is a good solution. Also, no need for async code all the way, which avoids some complexification of the code.

Asyncio is great when the program is more complex and the concurrent operations are all over the place and different

For me, it is still hard to know whether or not I will be able to implement a concurrent solution in my own projects (I have one that would terriby benefit from this)...but still don't get the whole picture.

But this exercise has put a little bit more light on my understanding of this topic. This is something I definitely need to work on harder.

Thanks Arjan! Great challenge.

I feel like this challenge single handedly took my understanding to the next level! I also love the great comments people post and your awesome replies Arjan. This whole 30 day challenge is Brilliant

Similar answer here. But I have kept the UrlTemplateClient code much similar to the "before" code, and I have created a decorator to make the function async.

def asynchronizer(func: Callable[..., Any]) -> Callable[..., Any]:
····async def inner(*args: Any, **kwargs: Any):
········return await asyncio.to_thread(func, *args, **kwargs)

····return inner

@asynchronizer
def get(self, data: dict[str, Any]) -> Any:
····url = self.template.format(**data)
····response = requests.get(url, timeout=5)
····response.raise_for_status() # Raise an exception if the request failed
····return response.json()